JavaScript SharedArrayBuffer Bloksiz Ma'lumotlar Tuzilmalari: Atomik Operatsiyalar

Zamonaviy veb-ishlab chiqish va Node.js kabi server tomonidagi JavaScript muhitlarida samarali parallel dasturlashga bo'lgan ehtiyoj doimiy ravishda o'sib bormoqda. Ilovalar murakkablashib, yuqori unumdorlikni talab qilgan sari, ishlab chiquvchilar bir nechta yadro va oqimlardan foydalanish usullarini tobora ko'proq o'rganmoqdalar. JavaScript-da bunga erishishning kuchli vositalaridan biri bu SharedArrayBuffer bo'lib, u Atomics operatsiyalari bilan birgalikda bloksiz ma'lumotlar tuzilmalarini yaratishga imkon beradi.

JavaScript-da Parallelizmga Kirish

An'anaga ko'ra, JavaScript bir oqimli til sifatida tanilgan. Bu ma'lum bir bajarilish kontekstida bir vaqtning o'zida faqat bitta vazifa bajarilishi mumkinligini anglatadi. Bu ishlab chiqishning ko'p jihatlarini soddalashtirsa-da, hisoblash talab qiladigan vazifalar uchun to'siq bo'lishi ham mumkin. Web Workers JavaScript kodini fon oqimlarida bajarish imkonini beradi, ammo ishchilar o'rtasidagi aloqa an'anaviy ravishda asinxron bo'lib, ma'lumotlarni nusxalashni o'z ichiga olgan.

SharedArrayBuffer bir vaqtning o'zida bir nechta oqimlar tomonidan kirish mumkin bo'lgan xotira maydonini ta'minlash orqali buni o'zgartiradi. Biroq, bu umumiy kirish poyga holatlari va ma'lumotlar buzilishi ehtimolini keltirib chiqaradi. Aynan shu yerda Atomics yordamga keladi. Atomics umumiy xotiradagi operatsiyalarning bo'linmas tarzda bajarilishini kafolatlaydigan, ma'lumotlar buzilishining oldini oladigan atomik operatsiyalar to'plamini taqdim etadi.

SharedArrayBuffer-ni Tushunish

SharedArrayBuffer bu qat'iy belgilangan uzunlikdagi xom binar ma'lumotlar buferini ifodalovchi JavaScript ob'ektidir. Oddiy ArrayBuffer-dan farqli o'laroq, SharedArrayBuffer bir nechta oqimlar (Web Workers) o'rtasida ma'lumotlarni aniq nusxalashni talab qilmasdan ulashilishi mumkin. Bu haqiqiy umumiy xotira parallelizmini ta'minlaydi.

Misol: SharedArrayBuffer yaratish

            
const sab = new SharedArrayBuffer(1024); // 1KB SharedArrayBuffer

            

              
                Copy
              
            
          

SharedArrayBuffer ichidagi ma'lumotlarga kirish uchun siz Int32Array yoki Float64Array kabi tiplangan massiv ko'rinishini yaratishingiz kerak:

            
const int32View = new Int32Array(sab);

            

              
                Copy
              
            
          

Bu SharedArrayBuffer ustida Int32Array ko'rinishini yaratadi, bu sizga umumiy xotiraga 32-bitli butun sonlarni o'qish va yozish imkonini beradi.

Atomicsning Roli

Atomics bu atomik operatsiyalarni ta'minlovchi global ob'ekt. Ushbu operatsiyalar umumiy xotiraga o'qish va yozish atomik tarzda bajarilishini kafolatlaydi, poyga holatlarining oldini oladi. Ular bir nechta oqimlar tomonidan xavfsiz tarzda kirish mumkin bo'lgan bloksiz ma'lumotlar tuzilmalarini yaratish uchun juda muhimdir.

Asosiy Atomik Operatsiyalar:

• Atomics.load(typedArray, index): Tiplangan massivdagi ko'rsatilgan indeksdan qiymatni o'qiydi.
• Atomics.store(typedArray, index, value): Tiplangan massivdagi ko'rsatilgan indeksga qiymat yozadi.
• Atomics.add(typedArray, index, value): Ko'rsatilgan indeksdagi qiymatga qiymat qo'shadi.
• Atomics.sub(typedArray, index, value): Ko'rsatilgan indeksdagi qiymatdan qiymatni ayiradi.
• Atomics.exchange(typedArray, index, value): Ko'rsatilgan indeksdagi qiymatni yangi qiymat bilan almashtiradi va asl qiymatni qaytaradi.
• Atomics.compareExchange(typedArray, index, expectedValue, newValue): Ko'rsatilgan indeksdagi qiymatni kutilgan qiymat bilan solishtiradi. Agar ular teng bo'lsa, qiymat yangi qiymat bilan almashtiriladi. Asl qiymatni qaytaradi.
• Atomics.wait(typedArray, index, expectedValue, timeout): Ko'rsatilgan indeksdagi qiymatning kutilgan qiymatdan o'zgarishini kutadi.
• Atomics.wake(typedArray, index, count): Ko'rsatilgan indeksdagi qiymatni kutayotgan ma'lum miqdordagi kutuvchilarni uyg'otadi.

Ushbu operatsiyalar bloksiz algoritmlarni yaratish uchun asos bo'lib xizmat qiladi.

Bloksiz Ma'lumotlar Tuzilmalarini Yaratish

Bloksiz ma'lumotlar tuzilmalari — bu bir nechta oqimlar tomonidan blokirovkalardan foydalanmasdan bir vaqtning o'zida kirish mumkin bo'lgan ma'lumotlar tuzilmalaridir. Bu an'anaviy blokirovka mexanizmlari bilan bog'liq qo'shimcha xarajatlar va potentsial deadlock (o'zaro bloklanish) holatlarini bartaraf etadi. SharedArrayBuffer va Atomics yordamida biz JavaScript-da turli xil bloksiz ma'lumotlar tuzilmalarini amalga oshirishimiz mumkin.

1. Bloksiz Hisoblagich

Oddiy misol — bu bloksiz hisoblagich. Bu hisoblagichni bir nechta oqimlar hech qanday blokirovkasiz oshirishi va kamaytirishi mumkin.

            
class LockFreeCounter {
  constructor() {
    this.buffer = new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT);
    this.view = new Int32Array(this.buffer);
  }

  increment() {
    Atomics.add(this.view, 0, 1);
  }

  decrement() {
    Atomics.sub(this.view, 0, 1);
  }

  getValue() {
    return Atomics.load(this.view, 0);
  }
}

// Ikki web workerda foydalanish misoli
const counter = new LockFreeCounter();

// Worker 1
for (let i = 0; i < 1000; i++) {
  counter.increment();
}

// Worker 2
for (let i = 0; i < 1000; i++) {
  counter.decrement();
}

// Ikkala ishchi ham tugagandan so'ng (tugashini ta'minlash uchun Promise.all kabi mexanizmdan foydalanib)
// counter.getValue() 0 ga yaqin bo'lishi kerak. Haqiqiy natija parallelizm tufayli farq qilishi mumkin

            

              
                Copy
              
            
          

2. Bloksiz Stek

Murakkabroq misol — bu bloksiz stek. Bu stek SharedArrayBufferda saqlanadigan bog'langan ro'yxat tuzilmasidan va bosh ko'rsatkichni boshqarish uchun atomik operatsiyalardan foydalanadi.

            
class LockFreeStack {
  constructor(capacity) {
    this.capacity = capacity;
    // Har bir tugun qiymat va keyingi tugunga ko'rsatkich uchun joy talab qiladi
    // Tugunlar va bosh ko'rsatkich uchun joy ajratish
    this.buffer = new SharedArrayBuffer((capacity + 1) * 2 * Int32Array.BYTES_PER_ELEMENT); // Har bir tugun uchun qiymat va keyingi ko'rsatkich + Bosh ko'rsatkich
    this.view = new Int32Array(this.buffer);

    this.headIndex = capacity * 2; // bosh ko'rsatkich saqlanadigan indeks
    Atomics.store(this.view, this.headIndex, -1); // Boshni null (-1) ga initsializatsiya qilish

    // Tugunlarni keyinchalik qayta ishlatish uchun ularning 'next' ko'rsatkichlari bilan initsializatsiya qilish.
    for (let i = 0; i < capacity; i++) {
      const nextIndex = (i === capacity - 1) ? -1 : i + 1; // oxirgi tugun nullga ishora qiladi
      this.setNext(i, nextIndex);
    }

    this.freeListHead = 0; // Bo'sh ro'yxat boshini birinchi tugunga initsializatsiya qilish
  }

  setNext(nodeIndex, nextIndex) {
     this.view[nodeIndex * 2 + 1] = nextIndex;
  }

  getNext(nodeIndex) {
     return this.view[nodeIndex * 2 + 1];
  }

  getValue(nodeIndex) {
    return this.view[nodeIndex * 2];
  }

  setValue(nodeIndex, value){ 
      this.view[nodeIndex*2] = value;
  }

  push(value) {
    let nodeIndex = this.freeListHead; // freeList dan olishga harakat qilish
    if (nodeIndex === -1) {
      return false; // stek to'lib ketdi
    }

    let nextFree = this.getNext(nodeIndex);
    // freeList boshini nextFree ga atomik tarzda yangilashga harakat qilish. Agar muvaffaqiyatsiz bo'lsa, kimdir uni allaqachon olgan.
    if (Atomics.compareExchange(this.view, this.capacity*2, nodeIndex, nextFree) !== nodeIndex) {
        return false; // agar raqobat bo'lsa, qayta urinib ko'ring
    }

    // bizda tugun bor, unga qiymatni yozamiz
    this.setValue(nodeIndex, value);

    let head;
    let newHead = nodeIndex;

    do {
      head = Atomics.load(this.view, this.headIndex);
      this.setNext(newHead, head);
      // Boshni newHead bilan solishtirish va almashtirish. Agar muvaffaqiyatsiz bo'lsa, bu boshqa oqim o'rtada push qilganini anglatadi
    } while (Atomics.compareExchange(this.view, this.headIndex, head, newHead) !== head);

    return true; // muvaffaqiyatli
  }

  pop() {
    let head = Atomics.load(this.view, this.headIndex);
    if (head === -1) {
      return undefined; // stek bo'sh
    }

    let next = this.getNext(head);
    // Boshni next ga yangilashga harakat qilish. Agar muvaffaqiyatsiz bo'lsa, bu boshqa oqim o'rtada pop qilganini anglatadi
    if (Atomics.compareExchange(this.view, this.headIndex, head, next) !== head) {
      return undefined; // qayta urinib ko'ring yoki muvaffaqiyatsizlikni bildiring.
    }

    const value = this.getValue(head);

    // Tugunni bo'sh ro'yxatga qaytarish.
    let currentFreeListHead = this.freeListHead;
    do {
        this.setNext(head, currentFreeListHead); // ozod qilingan tugunni joriy bo'sh ro'yxatga yo'naltirish
    } while(Atomics.compareExchange(this.view, this.capacity*2, currentFreeListHead, head) !== currentFreeListHead);

    return value; // muvaffaqiyatli
  }
}

// Foydalanish misoli (workerda):
const stack = new LockFreeStack(1024); // 1024 elementli stek yaratish

//push qilish
stack.push(10);
stack.push(20);

//pop qilish
const value1 = stack.pop(); // Qiymat 20
const value2 = stack.pop(); // Qiymat 10


            

              
                Copy
              
            
          

3. Bloksiz Navbat

Bloksiz navbat yaratish ham bosh, ham dum ko'rsatkichlarini atomik tarzda boshqarishni o'z ichiga oladi. Bu stekdan ko'ra murakkabroq, lekin Atomics.compareExchange yordamida o'xshash tamoyillarga amal qiladi.

Eslatma: Bloksiz navbatning batafsil implementatsiyasi ancha kengroq bo'lib, ushbu kirish doirasidan tashqarida, lekin stekdagiga o'xshash tushunchalarni, xotirani ehtiyotkorlik bilan boshqarishni va xavfsiz parallel kirishni kafolatlash uchun CAS (Compare-and-Swap) operatsiyalaridan foydalanishni o'z ichiga oladi.

Bloksiz Ma'lumotlar Tuzilmalarining Afzalliklari

• Yaxshilangan Unumdorlik: Blokirovkalarni bartaraf etish qo'shimcha xarajatlarni kamaytiradi va ziddiyatlarni oldini oladi, bu esa yuqori o'tkazuvchanlikka olib keladi.
• Deadlocklardan qochish: Bloksiz algoritmlar o'z tabiatiga ko'ra deadlock-dan xoli, chunki ular blokirovkalarga tayanmaydi.
• Yuqori Parallelizm: Ko'proq oqimlarga ma'lumotlar tuzilmasiga bir-birini bloklamasdan bir vaqtning o'zida kirish imkonini beradi.

Qiyinchiliklar va Mulohazalar

• Murakkablik: Bloksiz algoritmlarni amalga oshirish murakkab va xatolarga moyil bo'lishi mumkin. Parallelizm va xotira modellarini chuqur tushunishni talab qiladi.
• ABA Muammosi: ABA muammosi qiymat A dan B ga o'zgarganda va keyin yana A ga qaytganda yuzaga keladi. Solishtirish va almashtirish operatsiyasi noto'g'ri muvaffaqiyatli bo'lishi mumkin, bu esa ma'lumotlar buzilishiga olib keladi. ABA muammosining yechimlari ko'pincha solishtirilayotgan qiymatga hisoblagich qo'shishni o'z ichiga oladi.
• Xotirani Boshqarish: Xotira sizib chiqishini oldini olish va resurslarni to'g'ri ajratish va bo'shatishni ta'minlash uchun ehtiyotkorlik bilan xotirani boshqarish talab qilinadi. Xavfli ko'rsatkichlar yoki davrga asoslangan qayta tiklash kabi usullardan foydalanish mumkin.
• Nosozliklarni Tuzatish: Parallel kodni tuzatish qiyin bo'lishi mumkin, chunki muammolarni qayta tiklash qiyin bo'lishi mumkin. Debuggerlar va profilerlar kabi vositalar yordam berishi mumkin.

Amaliy Misollar va Qo'llash Holatlari

Bloksiz ma'lumotlar tuzilmalari yuqori parallelizm va past kechikish talab qilinadigan turli xil stsenariylarda qo'llanilishi mumkin:

• O'yinlarni Ishlab Chiqish: O'yin holatini boshqarish va bir nechta o'yin oqimlari o'rtasida ma'lumotlarni sinxronlashtirish.
• Real Vaqtdagi Tizimlar: Real vaqtdagi ma'lumotlar oqimlari va hodisalarni qayta ishlash.
• Yuqori Unumdorlikdagi Serverlar: Parallel so'rovlarni boshqarish va umumiy resurslarni boshqarish.
• Ma'lumotlarni Qayta Ishlash: Katta ma'lumotlar to'plamlarini parallel qayta ishlash.
• Moliyaviy Ilovalar: Yuqori chastotali savdo va risklarni boshqarish hisob-kitoblarini bajarish.

Misol: Moliyaviy Ilovada Real Vaqtda Ma'lumotlarni Qayta Ishlash

Real vaqtda fond bozori ma'lumotlarini qayta ishlaydigan moliyaviy ilovani tasavvur qiling. Bir nechta oqimlar fond narxlari, buyurtmalar kitobi va savdo pozitsiyalarini ifodalovchi umumiy ma'lumotlar tuzilmalariga kirishi va ularni yangilashi kerak. Bloksiz ma'lumotlar tuzilmalaridan foydalangan holda, dastur kiruvchi ma'lumotlarning yuqori hajmini samarali boshqarishi va savdolarning o'z vaqtida bajarilishini ta'minlashi mumkin.

Brauzer Muvofiqligi va Xavfsizlik

SharedArrayBuffer va Atomics zamonaviy brauzerlarda keng qo'llab-quvvatlanadi. Biroq, Spectre va Meltdown zaifliklari bilan bog'liq xavfsizlik muammolari tufayli, brauzerlar dastlab SharedArrayBufferni sukut bo'yicha o'chirib qo'ygan edi. Uni qayta yoqish uchun odatda quyidagi HTTP javob sarlavhalarini o'rnatish kerak:

            
Cross-Origin-Embedder-Policy: require-corp
Cross-Origin-Opener-Policy: same-origin

            

              
                Copy
              
            
          

Ushbu sarlavhalar sizning kelib chiqishingizni izolyatsiya qiladi, bu esa o'zaro kelib chiqish ma'lumotlarining sizib chiqishini oldini oladi. Serveringiz SharedArrayBufferdan foydalanadigan JavaScript kodini uzatishda ushbu sarlavhalarni yuborish uchun to'g'ri sozlanganligiga ishonch hosil qiling.

SharedArrayBuffer va Atomicsga Alternativalar

SharedArrayBuffer va Atomics parallel dasturlash uchun kuchli vositalarni taqdim etsa-da, boshqa yondashuvlar ham mavjud:

• Xabar Uzatish: Web Workers o'rtasida asinxron xabar uzatishdan foydalanish. Bu an'anaviyroq yondashuv, ammo oqimlar o'rtasida ma'lumotlarni nusxalashni o'z ichiga oladi.
• WebAssembly (WASM) Oqimlari: WebAssembly ham umumiy xotira va atomik operatsiyalarni qo'llab-quvvatlaydi, bu yuqori unumdorlikdagi parallel ilovalarni yaratish uchun ishlatilishi mumkin.
• Service Workers: Asosan keshlash va fon vazifalari uchun bo'lsa-da, service workers xabar uzatish yordamida parallel ishlov berish uchun ham ishlatilishi mumkin.

Eng yaxshi yondashuv ilovangizning o'ziga xos talablariga bog'liq. SharedArrayBuffer va Atomics katta hajmdagi ma'lumotlarni oqimlar o'rtasida minimal qo'shimcha xarajatlar va qat'iy sinxronizatsiya bilan ulashish kerak bo'lganda eng mos keladi.

Eng Yaxshi Amaliyotlar

• Sodda Qiling: Oddiy bloksiz algoritmlardan boshlang va kerak bo'lganda murakkablikni asta-sekin oshiring.
• Puxta Sinovdan O'tkazish: Poyga holatlari va boshqa parallelizm muammolarini aniqlash va tuzatish uchun parallel kodingizni puxta sinovdan o'tkazing.
• Kodni Ko'rib Chiqish: Kodingizni parallel dasturlash bilan tanish bo'lgan tajribali dasturchilar tomonidan ko'rib chiqilishini ta'minlang.
• Unumdorlik Profileridan Foydalaning: To'siqlarni aniqlash va kodingizni optimallashtirish uchun unumdorlikni profillash vositalaridan foydalaning.
• Kodingizni Hujjatlashtiring: Bloksiz algoritmlaringizning dizayni va amalga oshirilishini tushuntirish uchun kodingizni aniq hujjatlashtiring.

Xulosa

SharedArrayBuffer va Atomics JavaScript-da bloksiz ma'lumotlar tuzilmalarini yaratish uchun kuchli mexanizmni taqdim etib, samarali parallel dasturlashga imkon beradi. Bloksiz algoritmlarni amalga oshirishning murakkabligi qo'rqitishi mumkin bo'lsa-da, yuqori parallelizm va past kechikishni talab qiladigan ilovalar uchun potentsial unumdorlik afzalliklari sezilarli. JavaScript rivojlanishda davom etar ekan, bu vositalar yuqori unumdorlikka ega, kengaytiriladigan ilovalarni yaratish uchun tobora muhimroq bo'lib boradi. Parallelizm tamoyillarini chuqur tushunish bilan birga ushbu usullarni o'zlashtirish, ishlab chiquvchilarga ko'p yadroli dunyoda JavaScript unumdorligi chegaralarini kengaytirish imkonini beradi.

Qo'shimcha O'rganish Manbalari

• MDN Web Docs: SharedArrayBuffer
• MDN Web Docs: Atomics
• Bloksiz ma'lumotlar tuzilmalari va algoritmlari bo'yicha maqolalar.
• JavaScript-da parallel dasturlash bo'yicha blog postlari va maqolalar.